//============================================================================================
/**
 * @file	pkthln_poke_act.c
 * @brief	ポケスロンポケモンアクター
 * @author	Nozomu Saito
 *
 * モジュール名：PokeAct
 */
//============================================================================================

#include "common.h"
#include "system/clact_util.h"
#include "pkthln_poke_act.h"
#include "poketool/monsno.h"

#define RESOURCE_NUM	(4)
#define POKE_ACT_SLOT_MAX	(12)

#define MARKER_DISP_OFS_S	(3)
#define MARKER_DISP_OFS_M	(4)
#define MARKER_DISP_OFS_L	(5)

#define SHADOW_DISP_OFS_S	(3)
#define SHADOW_DISP_OFS_M	(4)
#define SHADOW_DISP_OFS_L	(5)

#define DRAW_OFS_X_L	(32)
#define DRAW_OFS_X_S	(16)
#define DRAW_OFS_Y_L	(32)
#define DRAW_OFS_Y_S	(16)

#define PRI_OFS	( POKE_ACT_SLOT_MAX )

typedef struct POKE_ACT_tag
{
	PCLACT_PTR PclActPtr;		//ポケモンセルアクター
	CLACT_WORK_PTR	ShadowPtr;	//影
	CLACT_WORK_PTR	MarkerPtr;	//マーカー
	int MarkerOfs;				//マーカー表示オフセット
	int ShadowOfs;				//影表示オフセット
	int DrawOfsX;
	int DrawOfsY;

	int TouchRange;
	int CX;
	int CY;

	int Space;
	int HitOfs;
	int HitRange;

	POKE_DIR Dir;
	ANM_TYPE AnmType;
	int BasePriOfs;
	BOOL	ShdwDspFbdn;		//影表示禁止
}POKE_ACT;

typedef struct PKTHLN_POKE_ACT_CNT_tag
{
	int HeapID;				//ヒープＩＤ
	int	PokeNum;			//管理ポケモンアクター数
	int BasePri;			//ポケモンアクターの基準プライオリティ

	BOOL	ActSetFlg;		//アクターセットが終了したかどうかのフラグ	TRUE:終了	FALSE:終了していない

	CLACT_SET_PTR 			ClActSetPtr;			// 参照セルアクターセット

	PCLACT_CNT_PTR PclActCntPtr;
	CMN_RES_CNT_PTR ResCntPtr;

	//ポケアクター
	POKE_ACT	PokeAct[POKE_ACT_SLOT_MAX];

}PKTHLN_POKE_ACT_CNT;

static void EntryCheckTask(TCB_PTR tcb, void* work);

static CLACT_WORK_PTR SetActor(POKE_ACT_CNT_PTR cnt_ptr, const int inBGPriority,
									const NNS_G2D_VRAM_TYPE inDrawArea,
									const u8 inResID);

//--------------------------------------------------------------------------------------------
/**
 * ポケスロンポケアクター初期化
 *
 * @param	inHeapID			ヒープID
 * @param	inPokeNum			登録ポケモン最大数
 * @param	inPri				基準プライオリティ
 * @param	inResCnrPtr			リソースコントローラポインタ
 * @param	pClActSet			アクターセットポインタ
 *
 * @return	POKE_ACT_CNT_PTR	アクターコントローラポインタ
 */
//--------------------------------------------------------------------------------------------
POKE_ACT_CNT_PTR PokeAct_Init(	const int inHeapID, const u8 inPokeNum, const int inPri,
								CMN_RES_CNT_PTR inResCntPtr, CLACT_SET_PTR pClActSet	)
{
	POKE_ACT_CNT_PTR cnt_ptr;
	int size = sizeof(PKTHLN_POKE_ACT_CNT);

	cnt_ptr = sys_AllocMemory(inHeapID, size);
	MI_CpuClear8( cnt_ptr, size);

	cnt_ptr->HeapID = inHeapID;
	cnt_ptr->PokeNum = inPokeNum;
	cnt_ptr->ResCntPtr = inResCntPtr;
	cnt_ptr->ClActSetPtr = pClActSet;
	cnt_ptr->BasePri = inPri;

	//ポケモンセルアクターマネージャ作成
	cnt_ptr->PclActCntPtr = PCLACT_Create(inHeapID);
	PCLACT_Init(cnt_ptr->PclActCntPtr, inPokeNum, pClActSet);

	return cnt_ptr;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンセルアクター解放関数
 *
 * @param	cnt_ptr			アクターコントローラーポインタ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_Free(POKE_ACT_CNT_PTR cnt_ptr)
{
	PCLACT_Free(cnt_ptr->PclActCntPtr);
	sys_FreeMemoryEz(cnt_ptr);
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンアクターセットタスクリクエスト
 *
 * @param	cnt_ptr			ポケモンアクターコントローラーポインタ
 * @param	inEntryNum		登録数
 * @param	inInfoTbl		モンスター情報
 * @param	inParam			アクターセットパラムポインタ
 * @param	inTcbPri		タスクプライオリティ
 * @param	inBaseResID		ベースリソースID
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetPokeActor(	POKE_ACT_CNT_PTR cnt_ptr, const int inEntryNum,
							const MONS_INFO *inInfoTbl,
							const PCLACT_SET_PARAM *inParam,
							const int inTcbPri,
							const int inBaseResID )
{
	int i;
	int tcb_pri;

	tcb_pri = inTcbPri;
	//総数から、作成するマーカーと影の個数が決定される
	//マーカー・影の有無は、リソースコントローラからもらう
	//影のサイズはinfoから決定
	//アクター作成する
	for(i=0;i<cnt_ptr->PokeNum;i++){

		if (inInfoTbl[i].CellType){	//大きい
			cnt_ptr->PokeAct[i].DrawOfsX = DRAW_OFS_X_L;
			cnt_ptr->PokeAct[i].DrawOfsY = DRAW_OFS_Y_L;
		}else{	//小さい
			cnt_ptr->PokeAct[i].DrawOfsX = DRAW_OFS_X_S;
			cnt_ptr->PokeAct[i].DrawOfsY = DRAW_OFS_Y_S;
		}

		//影のオフセット
		switch (inParam->ShadowPos[i]){
		case SHADOW_POS_A:
			cnt_ptr->PokeAct[i].ShadowOfs = SHADOW_DISP_OFS_S;
			break;
		case SHADOW_POS_B:
			cnt_ptr->PokeAct[i].ShadowOfs = SHADOW_DISP_OFS_M;
			break;
		case SHADOW_POS_C:
			cnt_ptr->PokeAct[i].ShadowOfs = SHADOW_DISP_OFS_L;
			break;
		default:
			OS_Printf("%d::shadow=%d\n",i,cnt_ptr->PokeAct[i].ShadowOfs);
			GF_ASSERT(0);
			cnt_ptr->PokeAct[i].ShadowOfs = SHADOW_DISP_OFS_S;
		}

		if ( CmnRes_CheckCmnResBit(cnt_ptr->ResCntPtr, CMN_RES_SHADOW_BIT) ){	//影
			cnt_ptr->PokeAct[i].ShadowPtr = SetActor( cnt_ptr, inParam->BGPriority,
													  inParam->DrawArea,
													  SHADOW_ID );
			//影の大きさ決定
			if (inInfoTbl[i].CellType){	//大きい影
				CLACT_AnmChg( cnt_ptr->PokeAct[i].ShadowPtr, 1 );
			}else{	//小さい影
				CLACT_AnmChg( cnt_ptr->PokeAct[i].ShadowPtr, 0 );
			}

			//ディグダ・ダグトリオは影を非表示
			if ( (inInfoTbl[i].MonsNo == MONSNO_DHIGUDA)||(inInfoTbl[i].MonsNo == MONSNO_DAGUTORIO) ){
				cnt_ptr->PokeAct[i].ShdwDspFbdn = TRUE;
				CLACT_SetDrawFlag(cnt_ptr->PokeAct[i].ShadowPtr, FALSE);
			}else{
				cnt_ptr->PokeAct[i].ShdwDspFbdn = FALSE;
			}
		}
		if ( CmnRes_CheckCmnResBit(cnt_ptr->ResCntPtr, CMN_RES_MARKER_BIT) ){	//マーカー
			cnt_ptr->PokeAct[i].MarkerPtr = SetActor( cnt_ptr, inParam->BGPriority,
													  inParam->DrawArea,
													  MARKER_ID );
			//ネットIDで色分け
			GF_ASSERT( inInfoTbl[i].NetID < 4 );
			CLACT_AnmChg( cnt_ptr->PokeAct[i].MarkerPtr, inInfoTbl[i].NetID );
			//マーカーのオフセット
			switch (inParam->ShadowPos[i]){
			case SHADOW_POS_A:
				cnt_ptr->PokeAct[i].MarkerOfs = MARKER_DISP_OFS_S;
				break;
			case SHADOW_POS_B:
				cnt_ptr->PokeAct[i].MarkerOfs = MARKER_DISP_OFS_M;
				break;
			case SHADOW_POS_C:
				cnt_ptr->PokeAct[i].MarkerOfs = MARKER_DISP_OFS_L;
				break;
			default:
				GF_ASSERT(0);
				cnt_ptr->PokeAct[i].MarkerOfs = MARKER_DISP_OFS_S;
			}
		}

		cnt_ptr->PokeAct[i].BasePriOfs = PRI_OFS;

	}		//end for

	//
	//ポケモンセルアクターセットタスクリクエスト
	if (tcb_pri <= 0){
		tcb_pri = 1;
	}
	PCLACT_SetPokeClActor(cnt_ptr->PclActCntPtr, inEntryNum, inInfoTbl, inParam, tcb_pri-1, inBaseResID);

	//セットタスク終了監視タスクセット
	TCB_Add(EntryCheckTask, cnt_ptr, tcb_pri);
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンアクターセットタスク終了チェック関数
 *
 * @param	cnt_ptr			ポケモンアクターコントローラーポインタ
 *
 * @return	BOOL			TRUE：終了	FALSE：継続
 */
//--------------------------------------------------------------------------------------------
BOOL PokeAct_CheckActSetTask(POKE_ACT_CNT_PTR	cnt_ptr)
{
	return cnt_ptr->ActSetFlg;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンアクターを返す
 *
 * @param	cnt_ptr			ポケモンアクターコントローラーポインタ
 * @param	inIndex			インデックス
 *
 * @return	POKE_ACT__PTR		ポケモンアクターポインタ
 */
//--------------------------------------------------------------------------------------------
POKE_ACT_PTR PokeAct_GetPokeActPtr(POKE_ACT_CNT_PTR cnt_ptr, const u8 inIndex)
{
	GF_ASSERT(inIndex < cnt_ptr->PokeNum);
	return &(cnt_ptr->PokeAct[inIndex]);
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンセルアクターを返す
 *
 * @param	ptr				ポケモンアクターポインタ
 *
 * @return	PCLACT_PTR		ポケモンセルアクターポインタ
 */
//--------------------------------------------------------------------------------------------
PCLACT_PTR PokeAct_GetPclActPtr(POKE_ACT_PTR ptr)
{
	return ptr->PclActPtr;
}

//--------------------------------------------------------------------------------------------
/**
 * エントリー監視タスク
 *
 * @param	tcb		TCBポインタ
 * @param	work	ワークポインタ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
static void EntryCheckTask(TCB_PTR tcb, void* work)
{
	POKE_ACT_CNT_PTR cnt_ptr = work;

	//ポケモンセルアクターセット終了？
	if( PCLACT_CheckActSetTask(cnt_ptr->PclActCntPtr) ){
		int i;
		int pri;

		pri = cnt_ptr->BasePri;
		//関連付け
		for(i=0;i<cnt_ptr->PokeNum;i++){
			cnt_ptr->PokeAct[i].PclActPtr = PCLACT_GetPclActPtr(cnt_ptr->PclActCntPtr, i);
			//プライオリティセット
			PokeAct_SetPriority(&cnt_ptr->PokeAct[i], pri++);
			//グラフィック上部空白値セット
			cnt_ptr->PokeAct[i].Space = PCLACT_GetSpaceHeight(cnt_ptr->PokeAct[i].PclActPtr);
		}
		cnt_ptr->ActSetFlg = TRUE;
		TCB_Delete(tcb);
	}
}


//--------------------------------------------------------------------------------------------
/**
 * アクターセット
 *
 * @param	cnt_ptr			ポケモンアクターコントローラーポインタ
 * @param	inBGPriority	ＢＧプライオリティー
 * @param	inDrawArea		描画エリア
 * @param	inResID			リソースＩＤ
 *
 * @return	CLACT_WORK_PTR		アクターポインタ
 */
//--------------------------------------------------------------------------------------------
static CLACT_WORK_PTR SetActor(POKE_ACT_CNT_PTR cnt_ptr, const int inBGPriority,
									const NNS_G2D_VRAM_TYPE inDrawArea,
									const u8 inResID)
{
	CLACT_HEADER			cl_act_header;
	CLACT_WORK_PTR			clact_ptr;

	// セルアクターヘッダ作成
	CLACT_U_MakeHeader(	&cl_act_header,
						inResID, CMN_RES_PAL_ID, inResID, inResID,
						CLACT_U_HEADER_DATA_NONE, CLACT_U_HEADER_DATA_NONE,
						0, inBGPriority,
						CmnRes_GetResMngPtr(cnt_ptr->ResCntPtr, CLACT_U_CHAR_RES),
						CmnRes_GetResMngPtr(cnt_ptr->ResCntPtr, CLACT_U_PLTT_RES),
						CmnRes_GetResMngPtr(cnt_ptr->ResCntPtr, CLACT_U_CELL_RES),
						CmnRes_GetResMngPtr(cnt_ptr->ResCntPtr, CLACT_U_CELLANM_RES),
						NULL,NULL);

	{
		//登録情報格納
		CLACT_ADD add;
		NNS_G2D_VRAM_TYPE draw_area;
		if (inDrawArea == NNS_G2D_VRAM_TYPE_MAX){
			draw_area = NNS_G2D_VRAM_TYPE_2DMAIN;
		}else{
			draw_area = inDrawArea;
		}

		add.ClActSet	= cnt_ptr->ClActSetPtr;
		add.ClActHeader	= &cl_act_header;
		add.heap		= cnt_ptr->HeapID;
		//↓この辺は後設定できるようにする
		add.mat.x		= 0;
		add.mat.y		= 0;		//画面は上下連続している
		add.mat.z		= 0;
		add.sca.x		= FX32_ONE;
		add.sca.y		= FX32_ONE;
		add.sca.z		= FX32_ONE;
		add.rot			= 0;
		add.pri			= 0;
		add.DrawArea	= draw_area;
		//↑

		clact_ptr = CLACT_Add(&add);
		CLACT_SetAnmFlag(clact_ptr,1);
		CLACT_AnmChg( clact_ptr,0 );
		CLACT_SetDrawFlag(clact_ptr, 0);	//非表示

	}

	return clact_ptr;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンの表示状態切り替え
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inDisp		表示状態	0以外：表示　0:非表示
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_DispCnt(POKE_ACT_PTR poke_ptr, const u8 inDisp)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	CLACT_SetDrawFlag(clact_ptr, inDisp);

	//影
	if (poke_ptr->ShadowPtr != NULL){
		//影表示禁止ポケ（ディグダ・ダグトリオ）は影を非表示
		if ( poke_ptr->ShdwDspFbdn ){
			CLACT_SetDrawFlag(poke_ptr->ShadowPtr, FALSE);
		}else{
			CLACT_SetDrawFlag(poke_ptr->ShadowPtr, inDisp);
		}
	}
	//マーカー
	if (poke_ptr->MarkerPtr != NULL){
		CLACT_SetDrawFlag(poke_ptr->MarkerPtr, inDisp);
	}
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン影の表示切り替え
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inDisp		表示状態	0以外：表示　0:非表示
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_ShdwDispCnt(POKE_ACT_PTR poke_ptr, const u8 inDisp)
{
	if (poke_ptr->ShadowPtr != NULL){
		//影表示禁止ポケ（ディグダ・ダグトリオ）は影を非表示
		if ( poke_ptr->ShdwDspFbdn ){
			CLACT_SetDrawFlag(poke_ptr->ShadowPtr, FALSE);
		}else{
			CLACT_SetDrawFlag(poke_ptr->ShadowPtr, inDisp);
		}
	}
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンの表示切り替え
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inDisp		表示状態	0以外：表示　0:非表示
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_PokeDispCnt(POKE_ACT_PTR poke_ptr, const u8 inDisp)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	CLACT_SetDrawFlag(clact_ptr, inDisp);
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンのプライオリティセット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	nPri
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetPriority(POKE_ACT_PTR poke_ptr, const int inPri)
{
	int pri;
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	pri = inPri;

	CLACT_DrawPriorityChg( clact_ptr, pri );

	//影
	if (poke_ptr->ShadowPtr != NULL){
		CLACT_DrawPriorityChg(poke_ptr->ShadowPtr, pri + (poke_ptr->BasePriOfs*2));
	}
	//マーカー
	if (poke_ptr->MarkerPtr != NULL){
		CLACT_DrawPriorityChg(poke_ptr->MarkerPtr, pri + (poke_ptr->BasePriOfs*1));
	}
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン・マーカー・影間のプライオリティオフセットを変更
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inOfs		オフセット
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_ChgPriorityOfs(POKE_ACT_PTR poke_ptr, int inOfs)
{
	poke_ptr->BasePriOfs = inOfs;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンのプライオリティ取得
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 *
 * @return	u32			プライオリティナンバー
 */
//--------------------------------------------------------------------------------------------
u32 PokeAct_GetPriority(POKE_ACT_PTR poke_ptr)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	return CLACT_DrawPriorityGet( clact_ptr );
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンのアフィンセット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inParam		パラメータ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetAffine(POKE_ACT_PTR poke_ptr, u8 inParam)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	//アフィンセット
	CLACT_SetAffineParam( clact_ptr, inParam);
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンのアフィン座標セット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inVec		座標
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetAffineVec(POKE_ACT_PTR poke_ptr, const VecFx32* inVec)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	CLACT_SetAffineMatrix(clact_ptr, inVec);
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンの向きをセット	(描画への反映なし)
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inDir		方向
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetDirDatOnly(POKE_ACT_PTR poke_ptr, const POKE_DIR inDir)
{
	poke_ptr->Dir = inDir;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンの向きをセット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inDir		方向
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetDir(POKE_ACT_PTR poke_ptr, const POKE_DIR inDir)
{
	CLACT_WORK_PTR clact_ptr;
	u8 anm_idx;

	poke_ptr->Dir = inDir;

	if (inDir == POKE_DIR_NONE){
		//方向指定なし
		return;
	}

	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);


	switch(inDir){
	case POKE_DIR_UP:
		anm_idx = 0; break;
	case POKE_DIR_DOWN:
		anm_idx = 1; break;
	case POKE_DIR_LEFT:
		anm_idx = 2; break;
	case POKE_DIR_RIGHT:
		anm_idx = 3; break;
	case POKE_DIR_UP_LV1:
		anm_idx = 4; break;
	case POKE_DIR_UP_LV2:
		anm_idx = 8; break;
	default:
		GF_ASSERT(0);
		return;
	}
	//アニメ変更
	CLACT_AnmChgCheck( clact_ptr, anm_idx );
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンのアニメをセット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inAnmType		アニメ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetAnm(POKE_ACT_PTR poke_ptr, const ANM_TYPE inAnmType)
{
	CLACT_WORK_PTR clact_ptr;
	u8 anm_idx;

	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);

	switch(inAnmType){
	case ANM_TYPE_WALK:
	case ANM_TYPE_RUN:
	case ANM_TYPE_DASH:
	case ANM_TYPE_STOP:
	case ANM_TYPE_THROW:
	case ANM_TYPE_PANIC:
	case ANM_TYPE_PANIC_MORE:
	case ANM_TYPE_DAMAGE:
	case ANM_TYPE_SJUMP:
		poke_ptr->AnmType = inAnmType;
		break;
	default:
		return;
	}

	//向きが関係するアニメは向きを参照
	if ((inAnmType!=ANM_TYPE_PANIC)&&
			(inAnmType!=ANM_TYPE_PANIC_MORE) ){
		switch(poke_ptr->Dir){
		case POKE_DIR_UP:
			anm_idx = 0+inAnmType; break;
		case POKE_DIR_DOWN:
			anm_idx = 1+inAnmType; break;
		case POKE_DIR_LEFT:
			anm_idx = 2+inAnmType; break;
		case POKE_DIR_RIGHT:
			anm_idx = 3+inAnmType; break;
		default:
			GF_ASSERT(0);
			return;
		}
	}else{
		anm_idx = inAnmType;
	}

	//アニメ変更
	CLACT_AnmChgCheck( clact_ptr, anm_idx );
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンのアニメをセット(VRAM転送型の時に使用)
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inAnmType		アニメ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetAnmTrns(POKE_ACT_PTR poke_ptr, const ANM_TYPE inAnmType)
{
	CLACT_WORK_PTR clact_ptr;
	u8 anm_idx;

	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);

	switch(inAnmType){
	case ANM_TYPE_WALK:
		poke_ptr->AnmType = 0;
		break;
	case ANM_TYPE_PANIC:
		poke_ptr->AnmType = 4;
		break;
	case ANM_TYPE_PANIC_MORE:
		poke_ptr->AnmType = 5;
		break;
	default:
		return;
	}

	//向きが関係するアニメは向きを参照
	if ((inAnmType!=ANM_TYPE_PANIC)&&
			(inAnmType!=ANM_TYPE_PANIC_MORE) ){
		switch(poke_ptr->Dir){
		case POKE_DIR_UP:
			anm_idx = 0; break;
		case POKE_DIR_DOWN:
			anm_idx = 1; break;
		case POKE_DIR_LEFT:
			anm_idx = 2; break;
		case POKE_DIR_RIGHT:
			anm_idx = 3; break;
		default:
			GF_ASSERT(0);
			return;
		}
	}else{
		anm_idx = poke_ptr->AnmType;
	}

	//アニメ変更
	CLACT_AnmChgCheck( clact_ptr, anm_idx );
}


//--------------------------------------------------------------------------------------------
/**
 * アニメ中かをチェック
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 *
 * @return	BOOL		TRUE:アニメ中
 */
//--------------------------------------------------------------------------------------------
BOOL PokeAct_AnmActiveCheck(POKE_ACT_PTR poke_ptr)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	return CLACT_AnmActiveCheck( clact_ptr );
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン位置をセット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inX			X座標
 * @param	inY			Y座標
 * @param	inDir		方向
 * @param	inFollow	影・マーカーの従属
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetPos(POKE_ACT_PTR poke_ptr, const int inX, const int inY, const BOOL inFollow)
{
	VecFx32 dst_vec;
	VecFx32 vec = {0,0,0};
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	vec.x = FX32_ONE*inX;
	vec.y = FX32_ONE*inY;

	poke_ptr->CX = inX+poke_ptr->DrawOfsX;
	poke_ptr->CY = inY+poke_ptr->DrawOfsY;

	//マーカー
	if (poke_ptr->MarkerPtr != NULL){
		dst_vec = vec;
		dst_vec.x += (poke_ptr->DrawOfsX * FX32_ONE);
		dst_vec.y += ((poke_ptr->DrawOfsY*2-poke_ptr->MarkerOfs) * FX32_ONE);
		CLACT_SetMatrix(poke_ptr->MarkerPtr, &dst_vec);
	}

	if (inFollow){
		//影
		if (poke_ptr->ShadowPtr != NULL){
			dst_vec = vec;
			dst_vec.x += (poke_ptr->DrawOfsX * FX32_ONE);
			dst_vec.y += ((poke_ptr->DrawOfsY*2-poke_ptr->ShadowOfs) * FX32_ONE);
			CLACT_SetMatrix(poke_ptr->ShadowPtr, &dst_vec);
		}
	}

	//キャラ詰めモード
	if(PCLACT_GetPokeChinkFlag(poke_ptr->PclActPtr)){
		vec.y += FX32_ONE*8;
	}

	//ポケ描画
	CLACT_SetMatrix(clact_ptr, &vec);

}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン位置をセット
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inX			X座標
 * @param	inY			Y座標
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetPosPokeOnly(POKE_ACT_PTR poke_ptr, const int inX, const int inY)
{
	VecFx32 dst_vec;
	VecFx32 vec = {0,0,0};
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	vec.x = FX32_ONE*inX;
	vec.y = FX32_ONE*inY;

	poke_ptr->CX = inX+poke_ptr->DrawOfsX;
	poke_ptr->CY = inY+poke_ptr->DrawOfsY;

	//キャラ詰めモード
	if(PCLACT_GetPokeChinkFlag(poke_ptr->PclActPtr)){
		vec.y += FX32_ONE*8;
	}

	//ポケ描画
	CLACT_SetMatrix(clact_ptr, &vec);

}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン位置を取得
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	outX			X座標
 * @param	outY			Y座標
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_GetPos(POKE_ACT_PTR poke_ptr, int *outX, int *outY )
{
	const VecFx32 *vec;
	CLACT_WORK_PTR clact_ptr = PCLACT_GetClActWorkPtr(PokeAct_GetPclActPtr(poke_ptr));
	vec = CLACT_GetMatrix(clact_ptr);
	*outX = vec->x / FX32_ONE;
	*outY = vec->y / FX32_ONE;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン位置を取得
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	outX			X座標
 * @param	outY			Y座標
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_GetCPos(POKE_ACT_PTR poke_ptr, int *outX, int *outY )
{
	*outX = poke_ptr->CX;
	*outY = poke_ptr->CY;
}

//--------------------------------------------------------------------------------------------
/**
 * ポケモンを移動
 *
 * @param	poke_ptr	ポケモンセルアクターポインタ
 * @param	inX			X座標
 * @param	inY			Y座標
 * @param	inDir		方向
 * @param	inFollow	影・マーカーの従属
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_Move(POKE_ACT_PTR poke_ptr, const int inX, const int inY, const POKE_DIR inDir, const BOOL inFollow)
{
	const VecFx32 *now_vec;
	VecFx32 vec, dst_vec;
	CLACT_WORK_PTR clact_ptr;

	poke_ptr->CX += inX;
	poke_ptr->CY += inY;

	vec.x = FX32_ONE * inX;
	vec.y = FX32_ONE * inY;
	vec.z = 0;

	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);
	PokeAct_SetDir(poke_ptr, inDir);
	now_vec = CLACT_GetMatrix(clact_ptr);
	VEC_Add( &vec, now_vec, &dst_vec );
	CLACT_SetMatrix(clact_ptr, &dst_vec);

	//マーカー
	if (poke_ptr->MarkerPtr != NULL){
		now_vec = CLACT_GetMatrix(poke_ptr->MarkerPtr);
		VEC_Add( &vec, now_vec, &dst_vec );
		CLACT_SetMatrix(poke_ptr->MarkerPtr, &dst_vec);
	}

	if (inFollow){
		//影
		if (poke_ptr->ShadowPtr != NULL){
			now_vec = CLACT_GetMatrix(poke_ptr->ShadowPtr);
			VEC_Add( &vec, now_vec, &dst_vec );
			CLACT_SetMatrix(poke_ptr->ShadowPtr, &dst_vec);
		}
	}
}


//--------------------------------------------------------------------------------------------
/**
 * パレット変更
 *
 * @param	cnt_ptr			ポケモンアクターコントローラーポインタ
 * @param	inIdx			インデックス
 * @param	inVramType		VRAMタイプ
 * @param	inPalData		パレットデータ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_ChangePalette(POKE_ACT_CNT_PTR cnt_ptr, const u8 inIdx, const NNS_G2D_VRAM_TYPE inVramType, u16 *inPalData )
{
	PCLACT_ChangePalette(cnt_ptr->PclActCntPtr, inIdx, inVramType, inPalData );
}

//--------------------------------------------------------------------------------------------
/**
 * タッチ半径セット
 *
 * @param	poke_ptr		ポケモンアクターポインタ
 * @param	inRange			半径
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetTouchRange(POKE_ACT_PTR poke_ptr, const int inRange)
{
	poke_ptr->TouchRange = inRange;
}

//--------------------------------------------------------------------------------------------
/**
 * あたり判定オフセットと半径セット
 *
 * @param	poke_ptr		ポケモンアクターポインタ
 * @param	inOfs			セル底からのオフセット
 * @param	inRange			半径
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetHitData(POKE_ACT_PTR poke_ptr, const int inOfs, const int inRange)
{
	poke_ptr->HitOfs = inOfs;
	poke_ptr->HitRange = inRange;
}

//--------------------------------------------------------------------------------------------
/**
 * あたり判定中心座標と半径を取得
 *
 * @param	poke_ptr		ポケモンアクターポインタ
 * @param	inX				指定X座標
 * @param	inY				指定Y座標
 * @param	outX			中心座標X
 * @param	outY			中心座標Y
 * @param	outRange		半径
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_GetHitData(POKE_ACT_PTR poke_ptr, const fx32 inX, const fx32 inY, fx32 *outX, fx32 *outY, int *outRange)
{
	PokeAct_GetHitPosByTouchPos(poke_ptr,inX, inY, outX, outY);
	*outRange = poke_ptr->HitRange;
}

//--------------------------------------------------------------------------------------------
/**
 * あたり判定半径を取得
 *
 * @param	poke_ptr		ポケモンアクターポインタ
 *
 * @return	int あたり半径
 */
//--------------------------------------------------------------------------------------------
int PokeAct_GetHitRange(POKE_ACT_PTR poke_ptr)
{
	return poke_ptr->HitRange;
}

//--------------------------------------------------------------------------------------------
/**
 * あたり判定オフセット取得
 *
 * @param	poke_ptr		ポケモンアクターポインタ
 *
 * @return	int				当たり判定オフセット
 */
//--------------------------------------------------------------------------------------------
int PokeAct_GetHitOfs(POKE_ACT_PTR poke_ptr)
{
	return poke_ptr->HitOfs;
}


//--------------------------------------------------------------------------------------------
/**
 * ポケモン位置をセット	(指定位置は影)
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inX			影X座標
 * @param	inY			影Y座標
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetPosShadow(POKE_ACT_PTR poke_ptr, const int inX, const int inY)
{
	int bottom, draw_top, draw_left;

	VecFx32 dst_vec;
	VecFx32 vec = {0,0,0};
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_ptr->PclActPtr);

	dst_vec = vec;
	dst_vec.x = inX * FX32_ONE;
	dst_vec.y = inY * FX32_ONE;

	//影
	if (poke_ptr->ShadowPtr != NULL){
		CLACT_SetMatrix(poke_ptr->ShadowPtr, &dst_vec);
	}
	//マーカー
	if (poke_ptr->MarkerPtr != NULL){
		CLACT_SetMatrix(poke_ptr->MarkerPtr, &dst_vec);
	}

	//セルの底部座標を算出
	bottom = inY + poke_ptr->ShadowOfs;
	//描画開始位置を算出
	draw_top = bottom - (poke_ptr->DrawOfsY*2);

	//描画Ｘ座標算出
	draw_left = inX - poke_ptr->DrawOfsX;

	//セル中心座標を求める
	poke_ptr->CX = inX;
	poke_ptr->CY = draw_top + poke_ptr->DrawOfsY;

	vec.x = FX32_ONE*draw_left;
	vec.y = FX32_ONE*draw_top;

	//キャラ詰めモード
	if(PCLACT_GetPokeChinkFlag(poke_ptr->PclActPtr)){
		vec.y += FX32_ONE*8;
	}

	//ポケ描画
	CLACT_SetMatrix(clact_ptr, &vec);

}

//--------------------------------------------------------------------------------------------
/**
 * ポケモン位置をセット	(指定位置はタッチ座標)
 *
 * @param	poke_ptr	ポケモンアクターポインタ
 * @param	inX			タッチX座標
 * @param	inY			タッチY座標
 * @param	inFollow	影・マーカーの従属
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PokeAct_SetPosTouch(POKE_ACT_PTR poke_ptr, const int inX, const int inY, const BOOL inFollow)
{
	int draw_top, left;
	//描画Ｙ座標を検出
	//セルの上部座標を算出
	draw_top = inY - ( ((poke_ptr->DrawOfsY*2) - poke_ptr->Space) / 2 + poke_ptr->Space );
	left = inX - poke_ptr->DrawOfsX;

	PokeAct_SetPos(poke_ptr, left, draw_top, inFollow);
}

//----------------------------------------------------------------------------
/**
 *	@brief	指定中心座標から、あたり中心座標を求める
 *
 *	@param	poke_ptr		ポケモンポインタ
 *	@param	inX				Ｘ座標
 *	@param	inY				Ｙ座標
 *	@param	*outX			あたりＸ座標
 *	@param	*outY			あたりＹ座標
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PokeAct_GetHitPosByTouchPos(POKE_ACT_PTR poke_ptr,
								const fx32 inX, const fx32 inY, fx32 *outX, fx32 *outY)
{
	fx32 top_ofs;
	fx32 draw_top;
	fx32 hit_ofs;
	int hit_pos;
	//セルの上部座標を算出
	top_ofs = ( ((poke_ptr->DrawOfsY*2) - poke_ptr->Space) / 2 + poke_ptr->Space ) * FX32_ONE;
	draw_top = inY - top_ofs;
	hit_ofs = ((poke_ptr->DrawOfsY*2) - poke_ptr->HitOfs) * FX32_ONE;
	hit_pos = draw_top + hit_ofs;

	*outX = inX;
	*outY = hit_pos;
///	OS_Printf("あたりの位置 = %d,%d\n",*outX, *outY);
}

//----------------------------------------------------------------------------
/**
 *	@brief	指定タッチ中心座標から、影座標を求める
 *
 *	@param	poke_ptr		ポケモンポインタ
 *	@param	inX				タッチＸ座標
 *	@param	inY				タッチＹ座標
 *	@param	*outX			影Ｘ座標
 *	@param	*outY			影Ｙ座標
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PokeAct_GetShadowPosByTouchPos(POKE_ACT_PTR poke_ptr,
								const int inX, const int inY, int *outX, int *outY)
{
	int draw_top;
	int shadow_pos;
	if (poke_ptr->ShadowPtr == NULL){
		GF_ASSERT(0);
		return;
	}
	//セルの上部座標を算出
	draw_top = inY - ( ((poke_ptr->DrawOfsY*2) - poke_ptr->Space) / 2 + poke_ptr->Space );
	shadow_pos = draw_top + (poke_ptr->DrawOfsY*2) - poke_ptr->ShadowOfs;

	*outX = inX;
	*outY = shadow_pos;
///	OS_Printf("影の位置 = %d,%d\n",*outX, *outY);
}

//----------------------------------------------------------------------------
/**
 *	@brief	指定した影座標から、タッチ中心座標を求める
 *
 *	@param	poke_ptr		ポケモンポインタ
 *	@param	inX				影Ｘ座標
 *	@param	inY				影Ｙ座標
 *	@param	*outX			タッチ中心Ｘ座標
 *	@param	*outY			タッチ中心Ｙ座標
 *
 *	@return none
 */
//-----------------------------------------------------------------------------
void PokeAct_GetTouchPosByShadowPos(POKE_ACT_PTR poke_ptr,
									const int inX, const int inY, int *outX, int *outY)
{
	int bottom, draw_top;

	//セルの底部座標を算出
	bottom = inY + poke_ptr->ShadowOfs;
	//描画開始位置を算出
	draw_top = bottom - (poke_ptr->DrawOfsY*2);

	*outX = inX;
	*outY = draw_top + ((poke_ptr->DrawOfsY*2) - poke_ptr->Space) / 2 + poke_ptr->Space;
}

//----------------------------------------------------------------------------
/**
 *	@brief	ポケモンのタッチ判定
 *
 *	@param	poke_ptr		ポケモンポインタ
 *	@param  inX			現在X座標
 *	@param	inY			現在Y座標
 *	@param	inTpX		タッチＸ座標
 *	@param	inTpY		タッチＹ座標
 *
 *	@return	BOOL			範囲内タッチなら、TRUEがかえる
 */
//-----------------------------------------------------------------------------
BOOL PokeAct_CheckTouch(POKE_ACT_PTR poke_ptr, const fx32 inX, const fx32 inY, const int inTpX, const int inTpY)
{
	fx32 len;
	VecFx32 dir_vec;
	VecFx32 poke_vec;
	VecFx32 vec;

	vec.x = inTpX*FX32_ONE;
	vec.y = inTpY*FX32_ONE;
	vec.z = 0;

	poke_vec.x = inX;
	poke_vec.y = inY;
	poke_vec.z = 0;

	VEC_Subtract( &vec, &poke_vec, &dir_vec );
	//方向ベクトルの長さを取得
	len = VEC_Mag(&dir_vec);

	//射程と比較
	if (len < poke_ptr->TouchRange*FX32_ONE){
		//タッチしている
		return TRUE;
	}
	return FALSE;
}

//-----------------------------------------------------------------------------
/**
 * セルアクターの拡縮率を指定
 *
 *	@param	poke_ptr		ポケモンポインタ
 *	@param  sx			現在X座標
 *	@param	sy			現在Y座標
 *
 *	@retval	none
 */
//-----------------------------------------------------------------------------
void PokeAct_SetScale(POKE_ACT_PTR poke_act, f32 sx, f32 sy)
{
	PCLACT_PTR pcl_act_ptr = PokeAct_GetPclActPtr(poke_act);
	PCLACT_SetScale(pcl_act_ptr, sx, sy);
}

//-----------------------------------------------------------------------------
/**
 * ポケの表示状態を取得
 *
 *	@param	poke_ptr		ポケモンポインタ
 *
 *	@retval	BOOL		TRUE:表示	FASLE:非表示
 */
//-----------------------------------------------------------------------------
BOOL PokeAct_GetDrawFlg(POKE_ACT_PTR poke_act)
{
	CLACT_WORK_PTR clact_ptr;
	clact_ptr = PCLACT_GetClActWorkPtr(poke_act->PclActPtr);
	if (CLACT_GetDrawFlag(clact_ptr)){
		return TRUE;
	}

	return FALSE;
}

//-----------------------------------------------------------------------------
/**
 *	@brief	サイズが大きいポケモンのキャラを上に１キャラ詰めるモードにする(ポケ転送前に呼ぶこと)
 *
 *	@param	cnt_ptr
 *
 *	@retval	none
 */
//-----------------------------------------------------------------------------
void PokeAct_SetBigPokeChinkFlag(POKE_ACT_CNT_PTR cnt_ptr)
{
	PCLACT_SetBigPokeChinkFlag( cnt_ptr->PclActCntPtr );
}

//-----------------------------------------------------------------------------
/**
 *	@brief	全ポケのアニメ停止コントロール
 *
 *	@param	cnt_ptr
 *	@param	inStop	停止フラグ
 *
 *	@retval	none
 */
//-----------------------------------------------------------------------------
void PokeAct_AllAnmStop(POKE_ACT_CNT_PTR cnt_ptr, const u8 inStop)
{
	u8 i;
	for(i=0;i<cnt_ptr->PokeNum;i++){
		POKE_ACT_PTR poke = PokeAct_GetPokeActPtr(cnt_ptr, i);
		PCLACT_PTR pc_act_ptr = PokeAct_GetPclActPtr(poke);
		CLACT_WORK_PTR clact_ptr = PCLACT_GetClActWorkPtr(pc_act_ptr);
		CLACT_SetAnmFlag(clact_ptr, !inStop);
	}		//end for

}